const axios = require('axios');
const fs = require('fs');
const path = require('path');

// 测试配置
const CONFIG = {
  baseURL: 'http://localhost:3000/api/v1',
  testUser: {
    username: 'user',
    password: '123456'
  },
  outputFile: path.join(__dirname, 'test_results.md')
};

// 记录测试结果
function logResult(message) {
  console.log(message);
  fs.appendFileSync(CONFIG.outputFile, message + '\n');
}

// 初始化测试结果文件
function initTestFile() {
  fs.writeFileSync(CONFIG.outputFile, '# 用户功能整合测试结果\n\n');
  fs.appendFileSync(CONFIG.outputFile, `测试时间: ${new Date().toLocaleString()}\n\n`);
}

// 登录获取token
async function login() {
  try {
    logResult(`正在登录用户: ${CONFIG.testUser.username}`);
    logResult(`尝试登录: ${CONFIG.baseURL}/auth/login`);
    
    const response = await axios.post(`${CONFIG.baseURL}/auth/login`, {
      username: CONFIG.testUser.username,
      password: CONFIG.testUser.password
    });
    
    logResult(`登录响应状态码: ${response.status}`);
    
    if (response.data.success && response.data.data && response.data.data.tokens && response.data.data.tokens.accessToken) {
      logResult('✅ 登录成功！');
      const userInfo = JSON.stringify(response.data.data.user, null, 2);
      logResult(`用户信息: ${userInfo}`);
      return {
        success: true,
        token: response.data.data.tokens.accessToken,
        user: response.data.data.user
      };
    } else {
      logResult('❌ 登录失败: 未找到accessToken');
      return { success: false, error: '登录响应中未找到accessToken' };
    }
  } catch (error) {
    logResult(`❌ 登录失败: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.message };
  }
}

// 测试用户统计信息接口
async function testUserStats(token) {
  try {
    logResult('\n开始测试用户统计信息接口...');
    logResult(`请求URL: ${CONFIG.baseURL}/users/me/stats`);
    
    const response = await axios.get(`${CONFIG.baseURL}/users/me/stats`, {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`响应数据: ${JSON.stringify(response.data, null, 2)}`);
    
    logResult('✅ 用户统计信息接口调用成功');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 获取统计信息失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

// 测试获取用户发布的视频
async function testGetUserVideos(token) {
  try {
    // 测试新的简化测试路由 - 隔离问题
    logResult('\n测试简化测试路由...');
    logResult(`请求URL: ${CONFIG.baseURL}/test/me/debug`);
    
    try {
      const testDebugResponse = await axios.get(`${CONFIG.baseURL}/test/me/debug`, {
        headers: {
          Authorization: `Bearer ${token}`
        }
      });
      
      logResult(`响应状态码: ${testDebugResponse.status}`);
      logResult(`响应数据: ${JSON.stringify(testDebugResponse.data, null, 2)}`);
      logResult('✅ 测试调试路由访问成功');
    } catch (testDebugError) {
      logResult(`❌ 测试调试路由访问失败`);
      logResult(`❌ 异常信息: ${testDebugError.message}`);
      if (testDebugError.response) {
        logResult(`❌ 响应状态: ${testDebugError.response.status}`);
        logResult(`❌ 响应数据: ${JSON.stringify(testDebugError.response.data)}`);
      }
    }
    
    // 测试简化测试视频路由
    logResult(`\n请求URL: ${CONFIG.baseURL}/test/me/videos`);
    
    try {
      const testVideoResponse = await axios.get(`${CONFIG.baseURL}/test/me/videos`, {
        headers: {
          Authorization: `Bearer ${token}`
        }
      });
      
      logResult(`响应状态码: ${testVideoResponse.status}`);
      logResult(`响应数据: ${JSON.stringify(testVideoResponse.data, null, 2)}`);
      logResult('✅ 测试视频路由访问成功');
    } catch (testVideoError) {
      logResult(`❌ 测试视频路由访问失败`);
      logResult(`❌ 异常信息: ${testVideoError.message}`);
      if (testVideoError.response) {
        logResult(`❌ 响应状态: ${testVideoError.response.status}`);
        logResult(`❌ 响应数据: ${JSON.stringify(testVideoError.response.data)}`);
      }
    }
    
    // 测试原始调试路由 - 检查/me路径是否能正确匹配
    logResult('\n测试原始调试路由...');
    logResult(`请求URL: ${CONFIG.baseURL}/users/me/debug`);
    
    try {
      const debugResponse = await axios.get(`${CONFIG.baseURL}/users/me/debug`, {
        headers: {
          Authorization: `Bearer ${token}`
        }
      });
      
      logResult(`响应状态码: ${debugResponse.status}`);
      logResult(`响应数据: ${JSON.stringify(debugResponse.data, null, 2)}`);
      logResult('✅ 调试路由访问成功');
    } catch (debugError) {
      logResult(`❌ 调试路由访问失败`);
      logResult(`❌ 异常信息: ${debugError.message}`);
      if (debugError.response) {
        logResult(`❌ 响应状态: ${debugError.response.status}`);
        logResult(`❌ 响应数据: ${JSON.stringify(debugError.response.data)}`);
      }
    }
    
    logResult('\n测试获取用户发布的视频...');
    logResult(`请求URL: ${CONFIG.baseURL}/users/me/videos`);
    
    const response = await axios.get(`${CONFIG.baseURL}/users/me/videos`, {
      headers: {
        Authorization: `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`发布视频总数: ${response.data.data.pagination.total}`);
    logResult(`当前页视频数量: ${response.data.data.videos.length}`);
    logResult(`分页信息: ${JSON.stringify(response.data.data.pagination)}`);
    
    if (response.data.data.videos.length > 0) {
      logResult('前3个发布视频信息:');
      response.data.data.videos.slice(0, 3).forEach((video, index) => {
        const videoInfo = `${index + 1}. ID: ${video.id}, 标题: ${video.title}, 发布时间: ${video.created_at}`;
        logResult(videoInfo);
      });
    }
    
    logResult('✅ 获取发布视频成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 获取发布视频失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

// 测试获取用户收藏的视频
async function testGetUserFavorites(token) {
  try {
    logResult('\n测试获取用户收藏的视频...');
    logResult(`请求URL: ${CONFIG.baseURL}/users/me/favorites/videos`);
    
    const response = await axios.get(`${CONFIG.baseURL}/users/me/favorites/videos`, {
      headers: {
        Authorization: `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`收藏视频总数: ${response.data.data.pagination.total}`);
    logResult(`当前页视频数量: ${response.data.data.videos.length}`);
    logResult(`分页信息: ${JSON.stringify(response.data.data.pagination)}`);
    
    if (response.data.data.videos.length > 0) {
      logResult('前3个收藏视频信息:');
      response.data.data.videos.slice(0, 3).forEach((video, index) => {
        const videoInfo = `${index + 1}. ID: ${video.id}, 标题: ${video.title}, 用户ID: ${video.user_id}`;
        logResult(videoInfo);
      });
    }
    
    logResult('✅ 获取收藏视频成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 获取收藏视频失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

// 测试获取用户点赞的视频
async function testGetUserLikedVideos(token) {
  try {
    logResult('\n测试获取用户点赞的视频...');
    logResult(`请求URL: ${CONFIG.baseURL}/users/me/likes/videos`);
    
    const response = await axios.get(`${CONFIG.baseURL}/users/me/likes/videos`, {
      headers: {
        Authorization: `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`点赞视频总数: ${response.data.data.pagination.total}`);
    logResult(`当前页视频数量: ${response.data.data.videos.length}`);
    logResult(`分页信息: ${JSON.stringify(response.data.data.pagination)}`);
    
    if (response.data.data.videos.length > 0) {
      logResult('前3个点赞视频信息:');
      response.data.data.videos.slice(0, 3).forEach((video, index) => {
        const videoInfo = `${index + 1}. ID: ${video.id}, 标题: ${video.title}, 用户ID: ${video.user_id}`;
        logResult(videoInfo);
      });
    }
    
    logResult('✅ 获取点赞视频成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 获取点赞视频失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

// 主测试函数
async function runTests() {
  try {
    // 初始化测试文件
    initTestFile();
    logResult('开始用户功能整合测试...');
    
    // 1. 登录
    const loginResult = await login();
    if (!loginResult.success) {
      logResult('\n❌ 测试失败: 无法登录');
      process.exit(1);
    }
    
    const { token, user } = loginResult;
    
    // 2. 测试获取用户统计信息
    const statsResult = await testUserStats(token);
    if (!statsResult.success) {
      logResult('\n❌ 测试失败: 获取统计信息失败');
      process.exit(1);
    }
    
    // 3. 测试获取用户发布的视频
    const videosResult = await testGetUserVideos(token);
    if (!videosResult.success) {
      logResult('\n❌ 测试失败: 获取发布视频失败');
      process.exit(1);
    }
    
    // 4. 测试获取用户收藏的视频
    const favoritesResult = await testGetUserFavorites(token);
    if (!favoritesResult.success) {
      logResult('\n❌ 测试失败: 获取收藏视频失败');
      process.exit(1);
    }
    
    // 5. 测试获取用户点赞的视频
    const likedVideosResult = await testGetUserLikedVideos(token);
    if (!likedVideosResult.success) {
      logResult('\n❌ 测试失败: 获取点赞视频失败');
      process.exit(1);
    }
    
    logResult('\n🎉 所有测试通过！');
    process.exit(0);
  } catch (error) {
    logResult(`\n❌ 测试过程中发生未预期错误: ${error}`);
    process.exit(1);
  }
}

// 运行测试
runTests();